// 《围棋》作者版权所有。保留所有权利。
// 此源代码的使用受BSD样式
// 许可证的约束，该许可证可以在许可证文件中找到。

package big

import (
	"math"
	"sync"
)

var threeOnce struct {
	sync.Once
	v *Float
}

func three() *Float {
	threeOnce.Do(func() {
		threeOnce.v = NewFloat(3.0)
	})
	return threeOnce.v
}

// Sqrt将z设置为x的四舍五入平方根，并返回它。
// 
// 如果z的精度为0，则在执行
// 操作之前，将其更改为x的精度。根据z的精度和
// 舍入模式进行舍入，但不计算z的精度。具体来说，z.Acc（）的
// 结果未定义。
// 
// 如果z<0，函数将崩溃。在
// 的情况下，z的值未定义。
func (z *Float) Sqrt(x *Float) *Float {
	if debugFloat {
		x.validate()
	}

	if z.prec == 0 {
		z.prec = x.prec
	}

	if x.Sign() == -1 {
		// 遵循IEEE754-2008（第7.2节）
		panic(ErrNaN{"square root of negative operand"})
	}

	// 手柄±0和+∞ 
	if x.form != finite {
		z.acc = Exact
		z.form = x.form
		z.neg = x.neg // IEEE754-2008要求√±0=±0 
		return z
	}

	// MantExp将参数的精度设置为接收器的精度，当z.prec>x.prec时，这将降低z.prec。在
	// MantExp调用后恢复。
	prec := z.prec
	b := x.MantExp(z)
	z.prec = prec

	// 计算√（z·2**b）作为
	// √（z）·2**（½b）如果b是
	// √（2z）·2**(⌊½b⌋)   如果b>0是奇数
	// √（½z）·2**(⌈½b⌉)   如果b<0是奇数
	switch b % 2 {
	case 0:
		// 。
	case 1:
		z.exp++
	case -1:
		z.exp--
	}

	z.sqrtInverse(z)

	// 重新附加减半指数
	return z.SetMantExp(z, b/2)
}

// 计算√通过求解t的
// 1/t²-x=0 
// （使用牛顿法），然后求出x（到z.prec精度）。
func (z *Float) sqrtInverse(x *Float) {
	// 让
	// f（t）=1/t²-x 
	// 然后
	// g（t）=f（t）/f'（t）=-½t（1-xt²）
	// 下一个猜测是由
	// t2 t=t（t）=½t（3-xt）
	u := newFloat(z.prec)
	v := newFloat(z.prec)
	three := three()
	ng := func(t *Float) *Float {
		u.prec = t.prec
		v.prec = t.prec
		return t.Set(u)
	}

	xf, _ := x.Float64()
	sqi := newFloat(z.prec)
	sqi.SetFloat64(1 / math.Sqrt(xf))
	for prec := z.prec + 32; sqi.prec < prec; {
		sqi.prec *= 2
		sqi = ng(sqi)
	}
	// /=sqi=1/√x 

	// x/√x=√x 
	z.Mul(x, sqi)
}

// newFloat返回一个新的*浮点，其空格为给定
// 精度的两倍。
func newFloat(prec2 uint32) *Float {
	z := new(Float)
	// nat。make确保切片长度大于0 
	z.mant = z.mant.make(int(prec2/_W) * 2)
	return z
}
